home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / cpu / adsp2100 / adsp2100.c < prev    next >
C/C++ Source or Header  |  1999-12-01  |  54KB  |  1,533 lines
  1. /*###################################################################################################
  2. **
  3. **
  4. **        ADSP2100.c
  5. **        Core implementation for the portable Analog ADSP-2100 emulator.
  6. **        Written by Aaron Giles
  7. **
  8. **
  9. **#################################################################################################*/
  10.  
  11. #include <stdio.h>
  12. #include <stddef.h>
  13. #include <stdlib.h>
  14. #include <string.h>
  15. #include "cpuintrf.h"
  16. #include "mamedbg.h"
  17. #include "adsp2100.h"
  18.  
  19.  
  20. /*###################################################################################################
  21. **    CONSTANTS
  22. **#################################################################################################*/
  23.  
  24. /* stack depths */
  25. #define    PC_STACK_DEPTH        16
  26. #define CNTR_STACK_DEPTH    4
  27. #define STAT_STACK_DEPTH    4
  28. #define LOOP_STACK_DEPTH    4
  29.  
  30.  
  31. /*###################################################################################################
  32. **    STRUCTURES & TYPEDEFS
  33. **#################################################################################################*/
  34.  
  35. /* 16-bit registers that can be loaded signed or unsigned */
  36. typedef union
  37. {
  38.     UINT16    u;
  39.     INT16    s;
  40. } ADSPREG16;
  41.  
  42.  
  43. /* the SHIFT result register is 32 bits */
  44. typedef union
  45. {
  46. #ifdef LSB_FIRST
  47.     struct { ADSPREG16 sr0, sr1; } srx; 
  48. #else
  49.     struct { ADSPREG16 sr1, sr0; } srx;
  50. #endif
  51.     UINT32 sr;
  52. } SHIFTRESULT;
  53.  
  54.  
  55. /* the MAC result register is 40 bits */
  56. typedef union
  57. {
  58. #ifdef LSB_FIRST
  59.     struct { ADSPREG16 mr0, mr1, mr2, mrzero; } mrx; 
  60. #else
  61.     struct { ADSPREG16 mrzero, mr2, mr1, mr0; } mrx;
  62. #endif
  63.     UINT64 mr;
  64. } MACRESULT;
  65.  
  66.  
  67. /* there are two banks of "core" registers */
  68. typedef struct ADSPCORE
  69. {
  70.     /* ALU registers */
  71.     ADSPREG16    ax0, ax1;
  72.     ADSPREG16    ay0, ay1;
  73.     ADSPREG16    ar;
  74.     ADSPREG16    af;
  75.     
  76.     /* MAC registers */
  77.     ADSPREG16    mx0, mx1;
  78.     ADSPREG16    my0, my1;
  79.     MACRESULT    mr;
  80.     ADSPREG16    mf;
  81.     
  82.     /* SHIFT registers */
  83.     ADSPREG16    si;
  84.     ADSPREG16    se;
  85.     ADSPREG16    sb;
  86.     SHIFTRESULT    sr;
  87.     
  88.     /* dummy registers */
  89.     ADSPREG16    zero;
  90. } ADSPCORE;
  91.  
  92.  
  93. /* ADSP-2100 Registers */
  94. typedef struct
  95. {
  96.     /* Core registers, 2 banks */
  97.     ADSPCORE    r[2];
  98.     
  99.     /* Memory addressing registers */
  100.     UINT16        i[8];
  101.     INT16        m[8];
  102.     UINT16        l[8];
  103.     UINT16        lmask[8];
  104.     UINT16        base[8];
  105.     UINT8        px;
  106.     
  107.     /* other CPU registers */
  108.     UINT16        pc;
  109.     UINT16        ppc;
  110.     UINT16        loop;
  111.     UINT8        loop_condition;
  112.     UINT16        cntr;
  113.  
  114.     /* status registers */
  115.     UINT8        astat;
  116.     UINT8        sstat;
  117.     UINT8        mstat;
  118.     UINT8        astat_clear;
  119.     UINT8        idle;
  120.     
  121.     /* stacks */
  122.     UINT32        loop_stack[LOOP_STACK_DEPTH];
  123.     UINT16        cntr_stack[CNTR_STACK_DEPTH];
  124.     UINT16        pc_stack[PC_STACK_DEPTH];
  125.     UINT8        stat_stack[STAT_STACK_DEPTH][3];
  126.     INT8        pc_sp;
  127.     INT8        cntr_sp;
  128.     INT8        stat_sp;
  129.     INT8        loop_sp;
  130.     
  131.     /* external I/O */
  132.     UINT8        flagout;
  133.     UINT8        flagin;
  134. #if SUPPORT_2101_EXTENSIONS
  135.     UINT8        fl0;
  136.     UINT8        fl1;
  137.     UINT8        fl2;
  138. #endif
  139.  
  140.     /* interrupt handling */
  141.     UINT8        imask;
  142.     UINT8        icntl;
  143.     UINT8        irq_state[4];
  144.     UINT8        irq_latch[4];
  145.     INT16        interrupt_cycles;
  146.     int            (*irq_callback)(int irqline);
  147. } adsp2100_Regs;
  148.  
  149.  
  150.  
  151. /*###################################################################################################
  152. **    PUBLIC GLOBAL VARIABLES
  153. **#################################################################################################*/
  154.  
  155. int    adsp2100_icount=50000;
  156.  
  157.  
  158. /*###################################################################################################
  159. **    PRIVATE GLOBAL VARIABLES
  160. **#################################################################################################*/
  161.  
  162. static adsp2100_Regs adsp2100;
  163. static ADSPCORE *core;
  164.  
  165.  
  166.  
  167. /*###################################################################################################
  168. **    PRIVATE FUNCTION PROTOTYPES
  169. **#################################################################################################*/
  170.  
  171. static void check_irqs(void);
  172.  
  173.  
  174.  
  175. /*###################################################################################################
  176. **    MEMORY ACCESSORS
  177. **#################################################################################################*/
  178.  
  179. INLINE UINT16 RWORD_DATA(UINT16 addr)
  180. {
  181.     addr = (addr & 0x3fff) << 1;
  182.     return ADSP2100_RDMEM_WORD(ADSP2100_DATA_OFFSET + addr);
  183. }
  184.  
  185. INLINE void WWORD_DATA(UINT16 addr, UINT16 data)
  186. {
  187.     addr = (addr & 0x3fff) << 1;
  188.     ADSP2100_WRMEM_WORD(ADSP2100_DATA_OFFSET + addr, data);
  189. }
  190.  
  191. INLINE UINT32 RWORD_PGM(UINT16 addr)
  192. {
  193.     addr = (addr & 0x3fff) << 2;
  194.     return *(UINT32 *)&OP_ROM[ADSP2100_PGM_OFFSET + addr] & 0x00ffffff;
  195. }
  196.  
  197. INLINE void WWORD_PGM(UINT16 addr, UINT32 data)
  198. {
  199.     addr = (addr & 0x3fff) << 2;
  200.     *(UINT32 *)&OP_ROM[ADSP2100_PGM_OFFSET + addr] = data;
  201. }
  202.  
  203. #define ROPCODE() RWORD_PGM(adsp2100.pc)
  204.  
  205.  
  206.  
  207. /*###################################################################################################
  208. **    IMPORT CORE UTILITIES
  209. **#################################################################################################*/
  210.  
  211. #include "2100ops.c"
  212.  
  213.  
  214.  
  215. /*###################################################################################################
  216. **    IRQ HANDLING
  217. **#################################################################################################*/
  218.  
  219. static void check_irqs(void)
  220. {
  221.     UINT8 check;
  222.     
  223.     /* check IRQ3 */
  224.     check = (adsp2100.icntl & 8) ? adsp2100.irq_latch[3] : adsp2100.irq_state[3];
  225.     if (check && (adsp2100.imask & 8))
  226.     {
  227.         /* clear the latch */
  228.         adsp2100.irq_latch[3] = 0;
  229.         
  230.         /* push the PC and the status */
  231.         pc_stack_push();
  232.         stat_stack_push();
  233.         
  234.         /* vector to location 3 & stop idling */
  235.         adsp2100.pc = 3;
  236.         adsp2100.idle = 0;
  237.         
  238.         /* mask all other interrupts */
  239.         adsp2100.imask &= ~0xf;
  240.         return;
  241.     }
  242.  
  243.     /* check IRQ2 */
  244.     check = (adsp2100.icntl & 4) ? adsp2100.irq_latch[2] : adsp2100.irq_state[2];
  245.     if (check && (adsp2100.imask & 4))
  246.     {
  247.         /* clear the latch */
  248.         adsp2100.irq_latch[2] = 0;
  249.  
  250.         /* push the PC and the status */
  251.         pc_stack_push();
  252.         stat_stack_push();
  253.  
  254.         /* vector to location 2 & stop idling */
  255.         adsp2100.pc = 2;
  256.         adsp2100.idle = 0;
  257.         
  258.         /* mask other interrupts based on the nesting bit */
  259.         if (adsp2100.icntl & 0x10) adsp2100.imask &= ~0x7;
  260.         else adsp2100.imask &= ~0xf;
  261.         return;
  262.     }
  263.  
  264.     /* check IRQ1 */
  265.     check = (adsp2100.icntl & 2) ? adsp2100.irq_latch[1] : adsp2100.irq_state[1];
  266.     if (check && (adsp2100.imask & 2))
  267.     {
  268.         /* clear the latch */
  269.         adsp2100.irq_latch[1] = 0;
  270.  
  271.         /* push the PC and the status */
  272.         pc_stack_push();
  273.         stat_stack_push();
  274.  
  275.         /* vector to location 1 & stop idling */
  276.         adsp2100.pc = 1;
  277.         adsp2100.idle = 0;
  278.         
  279.         /* mask other interrupts based on the nesting bit */
  280.         if (adsp2100.icntl & 0x10) adsp2100.imask &= ~0x3;
  281.         else adsp2100.imask &= ~0xf;
  282.         return;
  283.     }
  284.  
  285.     /* check IRQ0 */
  286.     check = (adsp2100.icntl & 1) ? adsp2100.irq_latch[0] : adsp2100.irq_state[0];
  287.     if (check && (adsp2100.imask & 1))
  288.     {
  289.         /* clear the latch */
  290.         adsp2100.irq_latch[0] = 0;
  291.  
  292.         /* push the PC and the status */
  293.         pc_stack_push();
  294.         stat_stack_push();
  295.  
  296.         /* vector to location 0 & stop idling*/
  297.         adsp2100.pc = 0;
  298.         adsp2100.idle = 0;
  299.         
  300.         /* mask other interrupts based on the nesting bit */
  301.         if (adsp2100.icntl & 0x10) adsp2100.imask &= ~0x1;
  302.         else adsp2100.imask &= ~0xf;
  303.         return;
  304.     }
  305. }
  306.  
  307.  
  308. void adsp2100_set_nmi_line(int state)
  309. {
  310.     /* no NMI line */
  311. }
  312.  
  313.  
  314. void adsp2100_set_irq_line(int irqline, int state)
  315. {
  316.     /* update the latched state */
  317.     if (state != CLEAR_LINE && adsp2100.irq_state[irqline] == CLEAR_LINE)
  318.         adsp2100.irq_latch[irqline] = 1;
  319.     
  320.     /* update the absolute state */
  321.     adsp2100.irq_state[irqline] = state;
  322.  
  323.     /* check for IRQs */
  324.     if (state != CLEAR_LINE)
  325.         check_irqs();
  326. }
  327.  
  328.  
  329. void adsp2100_set_irq_callback(int (*callback)(int irqline))
  330. {
  331.     adsp2100.irq_callback = callback;
  332. }
  333.  
  334.  
  335.  
  336. /*###################################################################################################
  337. **    CONTEXT SWITCHING
  338. **#################################################################################################*/
  339.  
  340. unsigned adsp2100_get_context(void *dst)
  341. {
  342.     /* copy the context */
  343.     if (dst)
  344.         *(adsp2100_Regs *)dst = adsp2100;
  345.     
  346.     /* return the context size */
  347.     return sizeof(adsp2100_Regs);
  348. }
  349.  
  350.  
  351. void adsp2100_set_context(void *src)
  352. {
  353.     /* copy the context */
  354.     if (src)
  355.         adsp2100 = *(adsp2100_Regs *)src;
  356.     
  357.     /* check for IRQs */
  358.     check_irqs();
  359. }
  360.  
  361.  
  362.  
  363. /*###################################################################################################
  364. **    SPECIAL REGISTER GETTERS AND SETTERS
  365. **#################################################################################################*/
  366.  
  367. unsigned adsp2100_get_pc(void)
  368. {
  369.     return adsp2100.pc;
  370. }
  371.  
  372.  
  373. void adsp2100_set_pc(unsigned val)
  374. {
  375.     adsp2100.pc = val;
  376. }
  377.  
  378.  
  379. unsigned adsp2100_get_sp(void)
  380. {
  381.     return adsp2100.pc_sp;
  382. }
  383.  
  384.  
  385. void adsp2100_set_sp(unsigned val)
  386. {
  387.     adsp2100.pc_sp = val;
  388. }
  389.  
  390.  
  391.  
  392. /*###################################################################################################
  393. **    INITIALIZATION AND SHUTDOWN
  394. **#################################################################################################*/
  395.  
  396. void adsp2100_reset(void *param)
  397. {
  398.     /* ensure that zero is zero */
  399.     adsp2100.r[0].zero.u = adsp2100.r[1].zero.u = 0;
  400.     
  401.     /* recompute the memory registers with their current values */
  402.     wr_l0(adsp2100.l[0]);  wr_i0(adsp2100.i[0]);
  403.     wr_l1(adsp2100.l[1]);  wr_i1(adsp2100.i[1]);
  404.     wr_l2(adsp2100.l[2]);  wr_i2(adsp2100.i[2]);
  405.     wr_l3(adsp2100.l[3]);  wr_i3(adsp2100.i[3]);
  406.     wr_l4(adsp2100.l[4]);  wr_i4(adsp2100.i[4]);
  407.     wr_l5(adsp2100.l[5]);  wr_i5(adsp2100.i[5]);
  408.     wr_l6(adsp2100.l[6]);  wr_i6(adsp2100.i[6]);
  409.     wr_l7(adsp2100.l[7]);  wr_i7(adsp2100.i[7]);
  410.     
  411.     /* reset PC and loops */
  412.     adsp2100.pc = 4;
  413.     adsp2100.ppc = -1;
  414.     adsp2100.loop = 0;
  415.     adsp2100.loop_condition = 0;
  416.     
  417.     /* reset status registers */
  418.     adsp2100.astat_clear = ~(CFLAG | VFLAG | NFLAG | ZFLAG);
  419.     adsp2100.mstat = 0;
  420.     adsp2100.sstat = 0;
  421.     adsp2100.idle = 0;
  422.     
  423.     /* reset stacks */
  424.     adsp2100.pc_sp = 0;
  425.     adsp2100.cntr_sp = 0;
  426.     adsp2100.stat_sp = 0;
  427.     adsp2100.loop_sp = 0;
  428.  
  429.     /* reset external I/O */
  430.     adsp2100.flagout = 0;
  431.     adsp2100.flagin = 0;
  432. #if SUPPORT_2101_EXTENSIONS
  433.     adsp2100.fl0 = 0;
  434.     adsp2100.fl1 = 0;
  435.     adsp2100.fl2 = 0;
  436. #endif
  437.  
  438.     /* reset interrupts */
  439.     adsp2100.imask = 0;
  440.     adsp2100.irq_state[0] = CLEAR_LINE;
  441.     adsp2100.irq_state[1] = CLEAR_LINE;
  442.     adsp2100.irq_state[2] = CLEAR_LINE;
  443.     adsp2100.irq_state[3] = CLEAR_LINE;
  444.     adsp2100.irq_latch[0] = CLEAR_LINE;
  445.     adsp2100.irq_latch[1] = CLEAR_LINE;
  446.     adsp2100.irq_latch[2] = CLEAR_LINE;
  447.     adsp2100.irq_latch[3] = CLEAR_LINE;
  448.     adsp2100.interrupt_cycles = 0;
  449. }
  450.  
  451.  
  452. void adsp2100_exit(void)
  453. {
  454.     /* nothing to do */
  455. }
  456.  
  457.  
  458.  
  459. /*###################################################################################################
  460. **    CORE EXECUTION LOOP
  461. **#################################################################################################*/
  462.  
  463. /* execute instructions on this CPU until icount expires */
  464. int adsp2100_execute(int cycles)
  465. {
  466.     /* reset the core */
  467.     mstat_changed();
  468.  
  469.     /* count cycles and interrupt cycles */
  470.     adsp2100_icount = cycles;
  471.     adsp2100_icount -= adsp2100.interrupt_cycles;
  472.     adsp2100.interrupt_cycles = 0;
  473.  
  474.     /* core execution loop */
  475.     do
  476.     {
  477.         UINT32 op, temp;
  478.  
  479.         /* debugging */
  480.         adsp2100.ppc = adsp2100.pc;    /* copy PC to previous PC */
  481.         CALL_MAME_DEBUG;
  482.  
  483.         /* instruction fetch */
  484.         op = ROPCODE();
  485.         
  486.         /* advance to the next instruction */        
  487.         if (adsp2100.pc != adsp2100.loop)
  488.             adsp2100.pc++;
  489.  
  490.         /* handle looping */
  491.         else
  492.         {
  493.             /* condition not met, keep looping */
  494.             if (!CONDITION(adsp2100.loop_condition))
  495.                 adsp2100.pc = pc_stack_top();
  496.                 
  497.             /* condition met; pop the PC and loop stacks and fall through */
  498.             else
  499.             {
  500.                 loop_stack_pop();
  501.                 pc_stack_pop_nop();
  502.                 adsp2100.pc++;
  503.             }
  504.         }
  505.  
  506.         /* parse the instruction */
  507.         switch (op >> 16)
  508.         {
  509.             case 0x00:
  510.                 /* 00000000 00000000 00000000  NOP */
  511.                 break;
  512.             case 0x02:
  513.                 /* 00000010 0000xxxx xxxxxxxx  modify flag out */
  514.                 /* 00000010 10000000 00000000  idle */
  515.                 /* 00000010 10000000 0000xxxx  idle (n) */
  516.                 if (op & 0x008000)
  517.                 {
  518.                     adsp2100.idle = 1;
  519.                     adsp2100_icount = 0;
  520.                 }
  521.                 else
  522.                 {
  523.                     if (CONDITION(op & 15))
  524.                     {
  525.                         switch ((op >> 4) & 3)
  526.                         {
  527.                             case 1:    adsp2100.flagout = !adsp2100.flagout;
  528.                             case 2: adsp2100.flagout = 0;
  529.                             case 3: adsp2100.flagout = 1;
  530.                         }
  531. #if SUPPORT_2101_EXTENSIONS
  532.                         switch ((op >> 6) & 3)
  533.                         {
  534.                             case 1:    adsp2100.fl0 = !adsp2100.fl0;
  535.                             case 2: adsp2100.fl0 = 0;
  536.                             case 3: adsp2100.fl0 = 1;
  537.                         }
  538.                         switch ((op >> 8) & 3)
  539.                         {
  540.                             case 1:    adsp2100.fl1 = !adsp2100.fl1;
  541.                             case 2: adsp2100.fl1 = 0;
  542.                             case 3: adsp2100.fl1 = 1;
  543.                         }
  544.                         switch ((op >> 10) & 3)
  545.                         {
  546.                             case 1:    adsp2100.fl2 = !adsp2100.fl2;
  547.                             case 2: adsp2100.fl2 = 0;
  548.                             case 3: adsp2100.fl2 = 1;
  549.                         }
  550. #endif
  551.                     }
  552.                 }
  553.                 break;
  554.             case 0x03:
  555.                 /* 00000011 xxxxxxxx xxxxxxxx  call or jump on flag in */
  556.                 if (op & 0x000002)
  557.                 {
  558.                     if (adsp2100.flagin)
  559.                     {
  560.                         if (op & 0x000001)
  561.                             pc_stack_push();
  562.                         adsp2100.pc = ((op >> 4) & 0x0fff) | ((op << 10) & 0x3000);
  563.                     }
  564.                 }
  565.                 else
  566.                 {
  567.                     if (!adsp2100.flagin)
  568.                     {
  569.                         if (op & 0x000001)
  570.                             pc_stack_push();
  571.                         adsp2100.pc = ((op >> 4) & 0x0fff) | ((op << 10) & 0x3000);
  572.                     }
  573.                 }
  574.                 break;
  575.             case 0x04:
  576.                 /* 00000100 00000000 000xxxxx  stack control */
  577.                 if (op & 0x000010) pc_stack_pop_nop();
  578.                 if (op & 0x000008) loop_stack_pop();
  579.                 if (op & 0x000004) cntr_stack_pop();
  580.                 if (op & 0x000002)
  581.                 {
  582.                     if (op & 0x000001) stat_stack_pop();
  583.                     else stat_stack_push();
  584.                 }
  585.                 break;
  586.             case 0x05:
  587.                 /* 00000101 00000000 00000000  saturate MR */
  588.                 if (GET_MV)
  589.                 {
  590.                     if (core->mr.mrx.mr2.u & 0x80)
  591.                         core->mr.mrx.mr2.u = 0xffff, core->mr.mrx.mr1.u = 0x8000, core->mr.mrx.mr0.u = 0x0000;
  592.                     else
  593.                         core->mr.mrx.mr2.u = 0x0000, core->mr.mrx.mr1.u = 0x7fff, core->mr.mrx.mr0.u = 0xffff;
  594.                 }
  595.                 break;
  596.             case 0x06:
  597.                 /* 00000110 000xxxxx 00000000  DIVS */
  598.                 {
  599.                     UINT16 xop = (op >> 8) & 7;
  600.                     UINT16 yop = (op >> 11) & 3;
  601.                     
  602.                     xop = ALU_GETXREG_UNSIGNED(xop);
  603.                     yop = ALU_GETYREG_UNSIGNED(yop);
  604.                     
  605.                     temp = xop ^ yop;
  606.                     adsp2100.astat = (adsp2100.astat & ~QFLAG) | ((temp >> 10) & QFLAG);
  607.                     core->af.u = (yop << 1) | (core->ay0.u >> 15);
  608.                     core->ay0.u = (core->ay0.u << 1) | (temp >> 15);
  609.                 }
  610.                 break;
  611.             case 0x07:
  612.                 /* 00000111 00010xxx 00000000  DIVQ */
  613.                 {
  614.                     UINT16 xop = (op >> 8) & 7;
  615.                     UINT16 res;
  616.                     
  617.                     xop = ALU_GETXREG_UNSIGNED(xop);
  618.                     
  619.                     if (GET_Q)
  620.                         res = core->af.u + xop;
  621.                     else
  622.                         res = core->af.u - xop;
  623.                     
  624.                     temp = res ^ xop;
  625.                     adsp2100.astat = (adsp2100.astat & ~QFLAG) | ((temp >> 10) & QFLAG);
  626.                     core->af.u = (res << 1) | (core->ay0.u >> 15);
  627.                     core->ay0.u = (core->ay0.u << 1) | ((~temp >> 15) & 0x0001);
  628.                 }
  629.                 break;
  630.             case 0x08:
  631.                 /* 00001000 00000000 0000xxxx  reserved */
  632.                 break;
  633.             case 0x09:
  634.                 /* 00001001 00000000 000xxxxx  modify address register */
  635.                 temp = (op >> 2) & 4;
  636.                 modify_address(temp + ((op >> 2) & 3), temp + (op & 3));
  637.                 break;
  638.             case 0x0a:
  639.                 /* 00001010 00000000 000xxxxx  conditional return */
  640.                 if (CONDITION(op & 15))
  641.                 {
  642.                     pc_stack_pop();
  643.                     
  644.                     /* RTI case */
  645.                     if (op & 0x000010)
  646.                         stat_stack_pop();
  647.                 }
  648.                 break;
  649.             case 0x0b:
  650.                 /* 00001011 00000000 xxxxxxxx  conditional jump (indirect address) */
  651.                 if (CONDITION(op & 15))
  652.                 {
  653.                     if (op & 0x000010)
  654.                         pc_stack_push();
  655.                     adsp2100.pc = adsp2100.i[4 + ((op >> 6) & 3)] & 0x3fff;
  656.                 }
  657.                 break;
  658.             case 0x0c:
  659.                 /* 00001100 xxxxxxxx xxxxxxxx  mode control */
  660. #if SUPPORT_2101_EXTENSIONS
  661.                 if (op & 0x000008) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_GOMODE) | ((op << 5) & MSTAT_GOMODE);
  662.                 if (op & 0x002000) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_INTEGER) | ((op >> 8) & MSTAT_INTEGER);
  663.                 if (op & 0x008000) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_TIMER) | ((op >> 9) & MSTAT_TIMER);
  664. #endif
  665.                 if (op & 0x000020) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_BANK) | ((op >> 4) & MSTAT_BANK);
  666.                 if (op & 0x000080) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_REVERSE) | ((op >> 5) & MSTAT_REVERSE);
  667.                 if (op & 0x000200) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_STICKYV) | ((op >> 6) & MSTAT_STICKYV);
  668.                 if (op & 0x000800) adsp2100.mstat = (adsp2100.mstat & ~MSTAT_SATURATE) | ((op >> 7) & MSTAT_SATURATE);
  669.                 mstat_changed();
  670.                 break;
  671.             case 0x0d:
  672.                 /* 00001101 0000xxxx xxxxxxxx  internal data move */
  673.                 WRITE_REG((op >> 10) & 3, (op >> 4) & 15, READ_REG((op >> 8) & 3, op & 15));
  674.                 break;
  675.             case 0x0e:
  676.                 /* 00001110 0xxxxxxx xxxxxxxx  conditional shift */
  677.                 if (CONDITION(op & 15)) shift_op(op);
  678.                 break;
  679.             case 0x0f:
  680.                 /* 00001111 0xxxxxxx xxxxxxxx  shift immediate */
  681.                 shift_op_imm(op);
  682.                 break;
  683.             case 0x10:
  684.                 /* 00010000 0xxxxxxx xxxxxxxx  shift with internal data register move */
  685.                 temp = READ_REG(0, op & 15);
  686.                 shift_op(op);
  687.                 WRITE_REG(0, (op >> 4) & 15, temp);
  688.                 break;
  689.             case 0x11:
  690.                 /* 00010001 xxxxxxxx xxxxxxxx  shift with pgm memory read/write */
  691.                 if (op & 0x8000)
  692.                 {
  693.                     pgm_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  694.                     shift_op(op);
  695.                 }
  696.                 else
  697.                 {
  698.                     shift_op(op);
  699.                     WRITE_REG(0, (op >> 4) & 15, pgm_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  700.                 }
  701.                 break;
  702.             case 0x12: 
  703.                 /* 00010010 xxxxxxxx xxxxxxxx  shift with data memory read/write DAG1 */
  704.                 if (op & 0x8000)
  705.                 {
  706.                     data_write((op >> 2) & 3, op & 3, READ_REG(0, (op >> 4) & 15));
  707.                     shift_op(op);
  708.                 }
  709.                 else
  710.                 {
  711.                     shift_op(op);
  712.                     WRITE_REG(0, (op >> 4) & 15, data_read((op >> 2) & 3, op & 3));
  713.                 }
  714.                 break;
  715.             case 0x13:
  716.                 /* 00010011 xxxxxxxx xxxxxxxx  shift with data memory read/write DAG2 */
  717.                 if (op & 0x8000)
  718.                 {
  719.                     data_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  720.                     shift_op(op);
  721.                 }
  722.                 else
  723.                 {
  724.                     shift_op(op);
  725.                     WRITE_REG(0, (op >> 4) & 15, data_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  726.                 }
  727.                 break;
  728.             case 0x14: case 0x15: case 0x16: case 0x17:
  729.                 /* 000101xx xxxxxxxx xxxxxxxx  do until */
  730.                 loop_stack_push(op & 0x3ffff);
  731.                 pc_stack_push();
  732.                 break;
  733.             case 0x18: case 0x19: case 0x1a: case 0x1b: 
  734.                 /* 000110xx xxxxxxxx xxxxxxxx  conditional jump (immediate addr) */
  735.                 if (CONDITION(op & 15)) adsp2100.pc = (op >> 4) & 0x3fff;
  736.                 break;
  737.             case 0x1c: case 0x1d: case 0x1e: case 0x1f:
  738.                 /* 000111xx xxxxxxxx xxxxxxxx  conditional call (immediate addr) */
  739.                 if (CONDITION(op & 15))
  740.                 {
  741.                     pc_stack_push();
  742.                     adsp2100.pc = (op >> 4) & 0x3fff;
  743.                 }
  744.                 break;
  745.             case 0x20: case 0x21:
  746.                 /* 0010000x xxxxxxxx xxxxxxxx  conditional MAC to MR */
  747.                 if (CONDITION(op & 15)) mac_op_mr(op);
  748.                 break;
  749.             case 0x22: case 0x23:
  750.                 /* 0010001x xxxxxxxx xxxxxxxx  conditional ALU to AR */
  751.                 if (CONDITION(op & 15)) alu_op_ar(op);
  752.                 break;
  753.             case 0x24: case 0x25:
  754.                 /* 0010010x xxxxxxxx xxxxxxxx  conditional MAC to MF */
  755.                 if (CONDITION(op & 15)) mac_op_mf(op);
  756.                 break;
  757.             case 0x26: case 0x27:
  758.                 /* 0010011x xxxxxxxx xxxxxxxx  conditional ALU to AF */
  759.                 if (CONDITION(op & 15)) alu_op_af(op);
  760.                 break;
  761.             case 0x28: case 0x29:
  762.                 /* 0010100x xxxxxxxx xxxxxxxx  MAC to MR with internal data register move */
  763.                 temp = READ_REG(0, op & 15);
  764.                 mac_op_mr(op);
  765.                 WRITE_REG(0, (op >> 4) & 15, temp);
  766.                 break;
  767.             case 0x2a: case 0x2b:
  768.                 /* 0010101x xxxxxxxx xxxxxxxx  ALU to AR with internal data register move */
  769.                 temp = READ_REG(0, op & 15);
  770.                 alu_op_ar(op);
  771.                 WRITE_REG(0, (op >> 4) & 15, temp);
  772.                 break;
  773.             case 0x2c: case 0x2d:
  774.                 /* 0010110x xxxxxxxx xxxxxxxx  MAC to MF with internal data register move */
  775.                 temp = READ_REG(0, op & 15);
  776.                 mac_op_mf(op);
  777.                 WRITE_REG(0, (op >> 4) & 15, temp);
  778.                 break;
  779.             case 0x2e: case 0x2f:
  780.                 /* 0010111x xxxxxxxx xxxxxxxx  ALU to AF with internal data register move */
  781.                 temp = READ_REG(0, op & 15);
  782.                 alu_op_af(op);
  783.                 WRITE_REG(0, (op >> 4) & 15, temp);
  784.                 break;
  785.             case 0x30: case 0x31: case 0x32: case 0x33: 
  786.                 /* 001100xx xxxxxxxx xxxxxxxx  load non-data register immediate (group 0) */
  787.                 WRITE_REG(0, op & 15, (INT16)(op >> 2) >> 2);
  788.                 break;
  789.             case 0x34: case 0x35: case 0x36: case 0x37:
  790.                 /* 001101xx xxxxxxxx xxxxxxxx  load non-data register immediate (group 1) */
  791.                 WRITE_REG(1, op & 15, (INT16)(op >> 2) >> 2);
  792.                 break;
  793.             case 0x38: case 0x39: case 0x3a: case 0x3b: 
  794.                 /* 001110xx xxxxxxxx xxxxxxxx  load non-data register immediate (group 2) */
  795.                 WRITE_REG(2, op & 15, (INT16)(op >> 2) >> 2);
  796.                 break;
  797.             case 0x3c: case 0x3d: case 0x3e: case 0x3f:
  798.                 /* 001111xx xxxxxxxx xxxxxxxx  load non-data register immediate (group 3) */
  799.                 WRITE_REG(3, op & 15, (INT16)(op >> 2) >> 2);
  800.                 break;
  801.             case 0x40: case 0x41: case 0x42: case 0x43: case 0x44: case 0x45: case 0x46: case 0x47:
  802.             case 0x48: case 0x49: case 0x4a: case 0x4b: case 0x4c: case 0x4d: case 0x4e: case 0x4f:
  803.                 /* 0100xxxx xxxxxxxx xxxxxxxx  load data register immediate */
  804.                 WRITE_REG(0, op & 15, (op >> 4) & 0xffff);
  805.                 break;
  806.             case 0x50: case 0x51:
  807.                 /* 0101000x xxxxxxxx xxxxxxxx  MAC to MR with pgm memory read */
  808.                 mac_op_mr(op);
  809.                 WRITE_REG(0, (op >> 4) & 15, pgm_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  810.                 break;
  811.             case 0x52: case 0x53:
  812.                 /* 0101001x xxxxxxxx xxxxxxxx  ALU to AR with pgm memory read */
  813.                 alu_op_ar(op);
  814.                 WRITE_REG(0, (op >> 4) & 15, pgm_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  815.                 break;
  816.             case 0x54: case 0x55:
  817.                 /* 0101010x xxxxxxxx xxxxxxxx  MAC to MF with pgm memory read */
  818.                 mac_op_mf(op);
  819.                 WRITE_REG(0, (op >> 4) & 15, pgm_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  820.                 break;
  821.             case 0x56: case 0x57:
  822.                 /* 0101011x xxxxxxxx xxxxxxxx  ALU to AF with pgm memory read */
  823.                 alu_op_af(op);
  824.                 WRITE_REG(0, (op >> 4) & 15, pgm_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  825.                 break;
  826.             case 0x58: case 0x59:
  827.                 /* 0101100x xxxxxxxx xxxxxxxx  MAC to MR with pgm memory write */
  828.                 pgm_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  829.                 mac_op_mr(op);
  830.                 break;
  831.             case 0x5a: case 0x5b:
  832.                 /* 0101101x xxxxxxxx xxxxxxxx  ALU to AR with pgm memory write */
  833.                 pgm_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  834.                 alu_op_ar(op);
  835.                 break;
  836.             case 0x5c: case 0x5d:
  837.                 /* 0101110x xxxxxxxx xxxxxxxx  ALU to MR with pgm memory write */
  838.                 pgm_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  839.                 mac_op_mf(op);
  840.                 break;
  841.             case 0x5e: case 0x5f:
  842.                 /* 0101111x xxxxxxxx xxxxxxxx  ALU to MF with pgm memory write */
  843.                 pgm_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  844.                 alu_op_af(op);
  845.                 break;
  846.             case 0x60: case 0x61:
  847.                 /* 0110000x xxxxxxxx xxxxxxxx  MAC to MR with data memory read DAG1 */
  848.                 mac_op_mr(op);
  849.                 WRITE_REG(0, (op >> 4) & 15, data_read((op >> 2) & 3, op & 3));
  850.                 break;
  851.             case 0x62: case 0x63:
  852.                 /* 0110001x xxxxxxxx xxxxxxxx  ALU to AR with data memory read DAG1 */
  853.                 alu_op_ar(op);
  854.                 WRITE_REG(0, (op >> 4) & 15, data_read((op >> 2) & 3, op & 3));
  855.                 break;
  856.             case 0x64: case 0x65:
  857.                 /* 0110010x xxxxxxxx xxxxxxxx  MAC to MF with data memory read DAG1 */
  858.                 mac_op_mf(op);
  859.                 WRITE_REG(0, (op >> 4) & 15, data_read((op >> 2) & 3, op & 3));
  860.                 break;
  861.             case 0x66: case 0x67:
  862.                 /* 0110011x xxxxxxxx xxxxxxxx  ALU to AF with data memory read DAG1 */
  863.                 alu_op_af(op);
  864.                 WRITE_REG(0, (op >> 4) & 15, data_read((op >> 2) & 3, op & 3));
  865.                 break;
  866.             case 0x68: case 0x69:
  867.                 /* 0110100x xxxxxxxx xxxxxxxx  MAC to MR with data memory write DAG1 */
  868.                 data_write((op >> 2) & 3, op & 3, READ_REG(0, (op >> 4) & 15));
  869.                 mac_op_mr(op);
  870.                 break;
  871.             case 0x6a: case 0x6b:
  872.                 /* 0110101x xxxxxxxx xxxxxxxx  ALU to AR with data memory write DAG1 */
  873.                 data_write((op >> 2) & 3, op & 3, READ_REG(0, (op >> 4) & 15));
  874.                 alu_op_ar(op);
  875.                 break;
  876.             case 0x6c: case 0x6d:
  877.                 /* 0111110x xxxxxxxx xxxxxxxx  MAC to MF with data memory write DAG1 */
  878.                 data_write((op >> 2) & 3, op & 3, READ_REG(0, (op >> 4) & 15));
  879.                 mac_op_mf(op);
  880.                 break;
  881.             case 0x6e: case 0x6f:
  882.                 /* 0111111x xxxxxxxx xxxxxxxx  ALU to AF with data memory write DAG1 */
  883.                 data_write((op >> 2) & 3, op & 3, READ_REG(0, (op >> 4) & 15));
  884.                 alu_op_af(op);
  885.                 break;
  886.             case 0x70: case 0x71:
  887.                 /* 0111000x xxxxxxxx xxxxxxxx  MAC to MR with data memory read DAG2 */
  888.                 mac_op_mr(op);
  889.                 WRITE_REG(0, (op >> 4) & 15, data_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  890.                 break;
  891.             case 0x72: case 0x73:
  892.                 /* 0111001x xxxxxxxx xxxxxxxx  ALU to AR with data memory read DAG2 */
  893.                 alu_op_ar(op);
  894.                 WRITE_REG(0, (op >> 4) & 15, data_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  895.                 break;
  896.             case 0x74: case 0x75:
  897.                 /* 0111010x xxxxxxxx xxxxxxxx  MAC to MF with data memory read DAG2 */
  898.                 mac_op_mf(op);
  899.                 WRITE_REG(0, (op >> 4) & 15, data_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  900.                 break;
  901.             case 0x76: case 0x77:
  902.                 /* 0111011x xxxxxxxx xxxxxxxx  ALU to AF with data memory read DAG2 */
  903.                 alu_op_af(op);
  904.                 WRITE_REG(0, (op >> 4) & 15, data_read(4 + ((op >> 2) & 3), 4 + (op & 3)));
  905.                 break;
  906.             case 0x78: case 0x79:
  907.                 /* 0111100x xxxxxxxx xxxxxxxx  MAC to MR with data memory write DAG2 */
  908.                 data_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  909.                 mac_op_mr(op);
  910.                 break;
  911.             case 0x7a: case 0x7b:
  912.                 /* 0111101x xxxxxxxx xxxxxxxx  ALU to AR with data memory write DAG2 */
  913.                 data_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  914.                 alu_op_ar(op);
  915.                 break;
  916.             case 0x7c: case 0x7d:
  917.                 /* 0111110x xxxxxxxx xxxxxxxx  MAC to MF with data memory write DAG2 */
  918.                 data_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  919.                 mac_op_mf(op);
  920.                 break;
  921.             case 0x7e: case 0x7f:
  922.                 /* 0111111x xxxxxxxx xxxxxxxx  ALU to AF with data memory write DAG2 */
  923.                 data_write(4 + ((op >> 2) & 3), 4 + (op & 3), READ_REG(0, (op >> 4) & 15));
  924.                 alu_op_af(op);
  925.                 break;
  926.             case 0x80: case 0x81: case 0x82: case 0x83: 
  927.                 /* 100000xx xxxxxxxx xxxxxxxx  read data memory (immediate addr) to reg group 0 */
  928.                 WRITE_REG(0, op & 15, RWORD_DATA((op >> 4) & 0xffff));
  929.                 break;
  930.             case 0x84: case 0x85: case 0x86: case 0x87:
  931.                 /* 100001xx xxxxxxxx xxxxxxxx  read data memory (immediate addr) to reg group 1 */
  932.                 WRITE_REG(1, op & 15, RWORD_DATA((op >> 4) & 0xffff));
  933.                 break;
  934.             case 0x88: case 0x89: case 0x8a: case 0x8b: 
  935.                 /* 100010xx xxxxxxxx xxxxxxxx  read data memory (immediate addr) to reg group 2 */
  936.                 WRITE_REG(2, op & 15, RWORD_DATA((op >> 4) & 0xffff));
  937.                 break;
  938.             case 0x8c: case 0x8d: case 0x8e: case 0x8f:
  939.                 /* 100011xx xxxxxxxx xxxxxxxx  read data memory (immediate addr) to reg group 3*/
  940.                 WRITE_REG(3, op & 15, RWORD_DATA((op >> 4) & 0xffff));
  941.                 break;
  942.             case 0x90: case 0x91: case 0x92: case 0x93: 
  943.                 /* 1001xxxx xxxxxxxx xxxxxxxx  write data memory (immediate addr) from reg group 0 */
  944.                 WWORD_DATA((op >> 4) & 0x3fff, READ_REG(0, op & 15));
  945.                 break;
  946.             case 0x94: case 0x95: case 0x96: case 0x97:
  947.                 /* 1001xxxx xxxxxxxx xxxxxxxx  write data memory (immediate addr) from reg group 1  */
  948.                 WWORD_DATA((op >> 4) & 0x3fff, READ_REG(1, op & 15));
  949.                 break;
  950.             case 0x98: case 0x99: case 0x9a: case 0x9b: 
  951.                 /* 1001xxxx xxxxxxxx xxxxxxxx  write data memory (immediate addr) from reg group 2  */
  952.                 WWORD_DATA((op >> 4) & 0x3fff, READ_REG(2, op & 15));
  953.                 break;
  954.             case 0x9c: case 0x9d: case 0x9e: case 0x9f:
  955.                 /* 1001xxxx xxxxxxxx xxxxxxxx  write data memory (immediate addr) from reg group 3  */
  956.                 WWORD_DATA((op >> 4) & 0x3fff, READ_REG(3, op & 15));
  957.                 break;
  958.             case 0xa0: case 0xa1: case 0xa2: case 0xa3: case 0xa4: case 0xa5: case 0xa6: case 0xa7:
  959.             case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf:
  960.                 /* 1010xxxx xxxxxxxx xxxxxxxx  data memory write (immediate) DAG1 */
  961.                 data_write((op >> 2) & 3, op & 3, (op >> 4) & 0xffff);
  962.                 break;
  963.             case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7:
  964.             case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf:
  965.                 /* 1011xxxx xxxxxxxx xxxxxxxx  data memory write (immediate) DAG2 */
  966.                 data_write(4 + ((op >> 2) & 3), 4 + (op & 3), (op >> 4) & 0xffff);
  967.                 break;
  968.             case 0xc0: case 0xc1:
  969.                 /* 1100000x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX0 & pgm read to AY0 */
  970.                 mac_op_mr(op); 
  971.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  972.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  973.                 break;
  974.             case 0xc2: case 0xc3:
  975.                 /* 1100001x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX0 & pgm read to AY0 */
  976.                 alu_op_ar(op); 
  977.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  978.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  979.                 break;
  980.             case 0xc4: case 0xc5:
  981.                 /* 1100010x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX1 & pgm read to AY0 */
  982.                 mac_op_mr(op); 
  983.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  984.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  985.                 break;
  986.             case 0xc6: case 0xc7:
  987.                 /* 1100011x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX1 & pgm read to AY0 */
  988.                 alu_op_ar(op); 
  989.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  990.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  991.                 break;
  992.             case 0xc8: case 0xc9:
  993.                 /* 1100100x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX0 & pgm read to AY0 */
  994.                 mac_op_mr(op); 
  995.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  996.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  997.                 break;
  998.             case 0xca: case 0xcb:
  999.                 /* 1100101x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX0 & pgm read to AY0 */
  1000.                 alu_op_ar(op); 
  1001.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1002.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1003.                 break;
  1004.             case 0xcc: case 0xcd:
  1005.                 /* 1100110x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX1 & pgm read to AY0 */
  1006.                 mac_op_mr(op); 
  1007.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1008.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1009.                 break;
  1010.             case 0xce: case 0xcf:
  1011.                 /* 1100111x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX1 & pgm read to AY0 */
  1012.                 alu_op_ar(op); 
  1013.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1014.                 core->ay0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1015.                 break;
  1016.             case 0xd0: case 0xd1:
  1017.                 /* 1101000x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX0 & pgm read to AY1 */
  1018.                 mac_op_mr(op); 
  1019.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  1020.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1021.                 break;
  1022.             case 0xd2: case 0xd3:
  1023.                 /* 1101001x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX0 & pgm read to AY1 */
  1024.                 alu_op_ar(op); 
  1025.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  1026.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1027.                 break;
  1028.             case 0xd4: case 0xd5:
  1029.                 /* 1101010x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX1 & pgm read to AY1 */
  1030.                 mac_op_mr(op); 
  1031.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  1032.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1033.                 break;
  1034.             case 0xd6: case 0xd7:
  1035.                 /* 1101011x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX1 & pgm read to AY1 */
  1036.                 alu_op_ar(op); 
  1037.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  1038.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1039.                 break;
  1040.             case 0xd8: case 0xd9:
  1041.                 /* 1101100x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX0 & pgm read to AY1 */
  1042.                 mac_op_mr(op); 
  1043.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1044.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1045.                 break;
  1046.             case 0xda: case 0xdb:
  1047.                 /* 1101101x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX0 & pgm read to AY1 */
  1048.                 alu_op_ar(op); 
  1049.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1050.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1051.                 break;
  1052.             case 0xdc: case 0xdd:
  1053.                 /* 1101110x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX1 & pgm read to AY1 */
  1054.                 mac_op_mr(op); 
  1055.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1056.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1057.                 break;
  1058.             case 0xde: case 0xdf:
  1059.                 /* 1101111x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX1 & pgm read to AY1 */
  1060.                 alu_op_ar(op); 
  1061.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1062.                 core->ay1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1063.                 break;
  1064.             case 0xe0: case 0xe1:
  1065.                 /* 1110000x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX0 & pgm read to MY0 */
  1066.                 mac_op_mr(op); 
  1067.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  1068.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1069.                 break;
  1070.             case 0xe2: case 0xe3:
  1071.                 /* 1110001x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX0 & pgm read to MY0 */
  1072.                 alu_op_ar(op); 
  1073.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  1074.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1075.                 break;
  1076.             case 0xe4: case 0xe5:
  1077.                 /* 1110010x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX1 & pgm read to MY0 */
  1078.                 mac_op_mr(op); 
  1079.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  1080.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1081.                 break;
  1082.             case 0xe6: case 0xe7:
  1083.                 /* 1110011x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX1 & pgm read to MY0 */
  1084.                 alu_op_ar(op); 
  1085.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  1086.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1087.                 break;
  1088.             case 0xe8: case 0xe9:
  1089.                 /* 1110100x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX0 & pgm read to MY0 */
  1090.                 mac_op_mr(op); 
  1091.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1092.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1093.                 break;
  1094.             case 0xea: case 0xeb:
  1095.                 /* 1110101x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX0 & pgm read to MY0 */
  1096.                 alu_op_ar(op); 
  1097.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1098.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1099.                 break;
  1100.             case 0xec: case 0xed:
  1101.                 /* 1110110x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX1 & pgm read to MY0 */
  1102.                 mac_op_mr(op); 
  1103.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1104.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1105.                 break;
  1106.             case 0xee: case 0xef:
  1107.                 /* 1110111x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX1 & pgm read to MY0 */
  1108.                 alu_op_ar(op); 
  1109.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1110.                 core->my0.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1111.                 break;
  1112.             case 0xf0: case 0xf1:
  1113.                 /* 1111000x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX0 & pgm read to MY1 */
  1114.                 mac_op_mr(op); 
  1115.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  1116.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1117.                 break;
  1118.             case 0xf2: case 0xf3:
  1119.                 /* 1111001x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX0 & pgm read to MY1 */
  1120.                 alu_op_ar(op); 
  1121.                 core->ax0.u = data_read((op >> 2) & 3, op & 3); 
  1122.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1123.                 break;
  1124.             case 0xf4: case 0xf5:
  1125.                 /* 1111010x xxxxxxxx xxxxxxxx  MAC to MR with data read to AX1 & pgm read to MY1 */
  1126.                 mac_op_mr(op); 
  1127.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  1128.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1129.                 break;
  1130.             case 0xf6: case 0xf7:
  1131.                 /* 1111011x xxxxxxxx xxxxxxxx  ALU to AR with data read to AX1 & pgm read to MY1 */
  1132.                 alu_op_ar(op); 
  1133.                 core->ax1.u = data_read((op >> 2) & 3, op & 3); 
  1134.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1135.                 break;
  1136.             case 0xf8: case 0xf9:
  1137.                 /* 1111100x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX0 & pgm read to MY1 */
  1138.                 mac_op_mr(op); 
  1139.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1140.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1141.                 break;
  1142.             case 0xfa: case 0xfb:
  1143.                 /* 1111101x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX0 & pgm read to MY1 */
  1144.                 alu_op_ar(op); 
  1145.                 core->mx0.u = data_read((op >> 2) & 3, op & 3); 
  1146.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1147.                 break;
  1148.             case 0xfc: case 0xfd:
  1149.                 /* 1111110x xxxxxxxx xxxxxxxx  MAC to MR with data read to MX1 & pgm read to MY1 */
  1150.                 mac_op_mr(op); 
  1151.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1152.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1153.                 break;
  1154.             case 0xfe: case 0xff:
  1155.                 /* 1111111x xxxxxxxx xxxxxxxx  ALU to AR with data read to MX1 & pgm read to MY1 */
  1156.                 alu_op_ar(op); 
  1157.                 core->mx1.u = data_read((op >> 2) & 3, op & 3); 
  1158.                 core->my1.u = pgm_read(4 + ((op >> 6) & 3), 4 + ((op >> 4) & 3));
  1159.                 break;
  1160.         }
  1161.  
  1162.         adsp2100_icount--;
  1163.  
  1164.     } while (adsp2100_icount > 0);
  1165.  
  1166.     adsp2100_icount -= adsp2100.interrupt_cycles;
  1167.     adsp2100.interrupt_cycles = 0;
  1168.  
  1169.     return cycles - adsp2100_icount;
  1170. }
  1171.  
  1172.  
  1173.  
  1174. /*###################################################################################################
  1175. **    REGISTER SNOOP
  1176. **#################################################################################################*/
  1177.  
  1178. unsigned adsp2100_get_reg(int regnum)
  1179. {
  1180.     switch (regnum)
  1181.     {
  1182.         case ADSP2100_PC: return adsp2100.pc;
  1183.  
  1184.         case ADSP2100_AX0: return core->ax0.u;
  1185.         case ADSP2100_AX1: return core->ax1.u;
  1186.         case ADSP2100_AY0: return core->ay0.u;
  1187.         case ADSP2100_AY1: return core->ay1.u;
  1188.         case ADSP2100_AR: return core->ar.u;
  1189.         case ADSP2100_AF: return core->af.u;
  1190.  
  1191.         case ADSP2100_MX0: return core->mx0.u;
  1192.         case ADSP2100_MX1: return core->mx1.u;
  1193.         case ADSP2100_MY0: return core->my0.u;
  1194.         case ADSP2100_MY1: return core->my1.u;
  1195.         case ADSP2100_MR0: return core->mr.mrx.mr0.u;
  1196.         case ADSP2100_MR1: return core->mr.mrx.mr1.u;
  1197.         case ADSP2100_MR2: return core->mr.mrx.mr2.u;
  1198.         case ADSP2100_MF: return core->mf.u;
  1199.  
  1200.         case ADSP2100_SI: return core->si.u;
  1201.         case ADSP2100_SE: return core->se.u;
  1202.         case ADSP2100_SB: return core->sb.u;
  1203.         case ADSP2100_SR0: return core->sr.srx.sr0.u;
  1204.         case ADSP2100_SR1: return core->sr.srx.sr1.u;
  1205.  
  1206.         case ADSP2100_I0: return adsp2100.i[0];
  1207.         case ADSP2100_I1: return adsp2100.i[1];
  1208.         case ADSP2100_I2: return adsp2100.i[2];
  1209.         case ADSP2100_I3: return adsp2100.i[3];
  1210.         case ADSP2100_I4: return adsp2100.i[4];
  1211.         case ADSP2100_I5: return adsp2100.i[5];
  1212.         case ADSP2100_I6: return adsp2100.i[6];
  1213.         case ADSP2100_I7: return adsp2100.i[7];
  1214.  
  1215.         case ADSP2100_L0: return adsp2100.l[0];
  1216.         case ADSP2100_L1: return adsp2100.l[1];
  1217.         case ADSP2100_L2: return adsp2100.l[2];
  1218.         case ADSP2100_L3: return adsp2100.l[3];
  1219.         case ADSP2100_L4: return adsp2100.l[4];
  1220.         case ADSP2100_L5: return adsp2100.l[5];
  1221.         case ADSP2100_L6: return adsp2100.l[6];
  1222.         case ADSP2100_L7: return adsp2100.l[7];
  1223.  
  1224.         case ADSP2100_M0: return adsp2100.m[0];
  1225.         case ADSP2100_M1: return adsp2100.m[1];
  1226.         case ADSP2100_M2: return adsp2100.m[2];
  1227.         case ADSP2100_M3: return adsp2100.m[3];
  1228.         case ADSP2100_M4: return adsp2100.m[4];
  1229.         case ADSP2100_M5: return adsp2100.m[5];
  1230.         case ADSP2100_M6: return adsp2100.m[6];
  1231.         case ADSP2100_M7: return adsp2100.m[7];
  1232.  
  1233.         case ADSP2100_PX: return adsp2100.px;
  1234.         case ADSP2100_CNTR: return adsp2100.cntr;
  1235.         case ADSP2100_ASTAT: return adsp2100.astat;
  1236.         case ADSP2100_SSTAT: return adsp2100.sstat;
  1237.         case ADSP2100_MSTAT: return adsp2100.mstat;
  1238.         
  1239.         case ADSP2100_PCSP: return adsp2100.pc_sp;
  1240.         case ADSP2100_CNTRSP: return adsp2100.cntr_sp;
  1241.         case ADSP2100_STATSP: return adsp2100.stat_sp;
  1242.         case ADSP2100_LOOPSP: return adsp2100.loop_sp;
  1243.         
  1244.         case ADSP2100_IMASK: return adsp2100.imask;
  1245.         case ADSP2100_ICNTL: return adsp2100.icntl;
  1246.         case ADSP2100_IRQSTATE0: return adsp2100.irq_state[0];
  1247.         case ADSP2100_IRQSTATE1: return adsp2100.irq_state[1];
  1248.         case ADSP2100_IRQSTATE2: return adsp2100.irq_state[2];
  1249.         case ADSP2100_IRQSTATE3: return adsp2100.irq_state[3];
  1250.         
  1251.         case ADSP2100_FLAGIN: return adsp2100.flagin;
  1252.         case ADSP2100_FLAGOUT: return adsp2100.flagout;
  1253. #if SUPPORT_2101_EXTENSIONS
  1254.         case ADSP2100_FL0: return adsp2100.fl0;
  1255.         case ADSP2100_FL1: return adsp2100.fl1;
  1256.         case ADSP2100_FL2: return adsp2100.fl2;
  1257. #endif
  1258.         case REG_PREVIOUSPC: return adsp2100.ppc;
  1259.         default:
  1260.             if (regnum <= REG_SP_CONTENTS)
  1261.             {
  1262.                 unsigned offset = REG_SP_CONTENTS - regnum;
  1263.                 if (offset < PC_STACK_DEPTH)
  1264.                     return adsp2100.pc_stack[offset];
  1265.             }
  1266.     }
  1267.     return 0;
  1268. }
  1269.  
  1270.  
  1271.  
  1272. /*###################################################################################################
  1273. **    REGISTER MODIFY
  1274. **#################################################################################################*/
  1275.  
  1276. void adsp2100_set_reg(int regnum, unsigned val)
  1277. {
  1278.     switch (regnum)
  1279.     {
  1280.         case ADSP2100_PC: adsp2100.pc = val; break;
  1281.  
  1282.         case ADSP2100_AX0: wr_ax0(val); break;
  1283.         case ADSP2100_AX1: wr_ax1(val); break;
  1284.         case ADSP2100_AY0: wr_ay0(val); break;
  1285.         case ADSP2100_AY1: wr_ay1(val); break;
  1286.         case ADSP2100_AR: wr_ar(val); break;
  1287.         case ADSP2100_AF: core->af.u = val; break;
  1288.  
  1289.         case ADSP2100_MX0: wr_mx0(val); break;
  1290.         case ADSP2100_MX1: wr_mx1(val); break;
  1291.         case ADSP2100_MY0: wr_my0(val); break;
  1292.         case ADSP2100_MY1: wr_my1(val); break;
  1293.         case ADSP2100_MR0: wr_mr0(val); break;
  1294.         case ADSP2100_MR1: wr_mr1(val); break;
  1295.         case ADSP2100_MR2: wr_mr2(val); break;
  1296.         case ADSP2100_MF: core->mf.u = val; break;
  1297.  
  1298.         case ADSP2100_SI: wr_si(val); break;
  1299.         case ADSP2100_SE: wr_se(val); break;
  1300.         case ADSP2100_SB: wr_sb(val); break;
  1301.         case ADSP2100_SR0: wr_sr0(val); break;
  1302.         case ADSP2100_SR1: wr_sr1(val); break;
  1303.  
  1304.         case ADSP2100_I0: wr_i0(val); break;
  1305.         case ADSP2100_I1: wr_i1(val); break;
  1306.         case ADSP2100_I2: wr_i2(val); break;
  1307.         case ADSP2100_I3: wr_i3(val); break;
  1308.         case ADSP2100_I4: wr_i4(val); break;
  1309.         case ADSP2100_I5: wr_i5(val); break;
  1310.         case ADSP2100_I6: wr_i6(val); break;
  1311.         case ADSP2100_I7: wr_i7(val); break;
  1312.  
  1313.         case ADSP2100_L0: wr_l0(val); break;
  1314.         case ADSP2100_L1: wr_l1(val); break;
  1315.         case ADSP2100_L2: wr_l2(val); break;
  1316.         case ADSP2100_L3: wr_l3(val); break;
  1317.         case ADSP2100_L4: wr_l4(val); break;
  1318.         case ADSP2100_L5: wr_l5(val); break;
  1319.         case ADSP2100_L6: wr_l6(val); break;
  1320.         case ADSP2100_L7: wr_l7(val); break;
  1321.  
  1322.         case ADSP2100_M0: wr_m0(val); break;
  1323.         case ADSP2100_M1: wr_m1(val); break;
  1324.         case ADSP2100_M2: wr_m2(val); break;
  1325.         case ADSP2100_M3: wr_m3(val); break;
  1326.         case ADSP2100_M4: wr_m4(val); break;
  1327.         case ADSP2100_M5: wr_m5(val); break;
  1328.         case ADSP2100_M6: wr_m6(val); break;
  1329.         case ADSP2100_M7: wr_m7(val); break;
  1330.  
  1331.         case ADSP2100_PX: wr_px(val); break;
  1332.         case ADSP2100_CNTR: adsp2100.cntr = val; break;
  1333.         case ADSP2100_ASTAT: wr_astat(val); break;
  1334.         case ADSP2100_SSTAT: wr_sstat(val); break;
  1335.         case ADSP2100_MSTAT: wr_mstat(val); break;
  1336.         
  1337.         case ADSP2100_PCSP: adsp2100.pc_sp = val; break;
  1338.         case ADSP2100_CNTRSP: adsp2100.cntr_sp = val; break;
  1339.         case ADSP2100_STATSP: adsp2100.stat_sp = val; break;
  1340.         case ADSP2100_LOOPSP: adsp2100.loop_sp = val; break;
  1341.         
  1342.         case ADSP2100_IMASK: wr_imask(val); break;
  1343.         case ADSP2100_ICNTL: wr_icntl(val); break;
  1344.         case ADSP2100_IRQSTATE0: adsp2100.irq_state[0] = val; break;
  1345.         case ADSP2100_IRQSTATE1: adsp2100.irq_state[1] = val; break;
  1346.         case ADSP2100_IRQSTATE2: adsp2100.irq_state[2] = val; break;
  1347.         case ADSP2100_IRQSTATE3: adsp2100.irq_state[3] = val; break;
  1348.         
  1349.         case ADSP2100_FLAGIN: adsp2100.flagin = val; break;
  1350.         case ADSP2100_FLAGOUT: adsp2100.flagout = val; break;
  1351. #if SUPPORT_2101_EXTENSIONS
  1352.         case ADSP2100_FL0: adsp2100.fl0 = val; break;
  1353.         case ADSP2100_FL1: adsp2100.fl1 = val; break;
  1354.         case ADSP2100_FL2: adsp2100.fl2 = val; break;
  1355. #endif
  1356.         default:
  1357.             if (regnum <= REG_SP_CONTENTS)
  1358.             {
  1359.                 unsigned offset = REG_SP_CONTENTS - regnum;
  1360.                 if (offset < PC_STACK_DEPTH)
  1361.                     adsp2100.pc_stack[offset] = val;
  1362.             }
  1363.     }
  1364. }
  1365.  
  1366.  
  1367. /*###################################################################################################
  1368. **    DEBUGGER DEFINITIONS
  1369. **#################################################################################################*/
  1370.  
  1371. static UINT8 adsp2100_reg_layout[] = 
  1372. {
  1373.     ADSP2100_PC,        ADSP2100_AX0,    ADSP2100_MX0,    -1,
  1374.     ADSP2100_CNTR,         ADSP2100_AX1,    ADSP2100_MX1,    -1,
  1375.     ADSP2100_MSTAT,     ADSP2100_AY0,    ADSP2100_MY0,    -1,
  1376.     ADSP2100_SSTAT,     ADSP2100_AY1,    ADSP2100_MY1,    -1,
  1377.     ADSP2100_PX,         ADSP2100_AR,    ADSP2100_MR0,    -1,
  1378.     ADSP2100_PCSP,         ADSP2100_AF,    ADSP2100_MR1,    -1,
  1379.     ADSP2100_CNTRSP,     ADSP2100_SI,    ADSP2100_MR2,    -1,
  1380.     ADSP2100_STATSP,     ADSP2100_SE,    ADSP2100_MF,    -1,
  1381.     ADSP2100_LOOPSP,     ADSP2100_SB,    100,            -1,
  1382.     ADSP2100_IMASK,        ADSP2100_SR0,    100,            -1,
  1383.     ADSP2100_ICNTL,        ADSP2100_SR1,    100,            -1,
  1384.     ADSP2100_I0,        ADSP2100_L0,    ADSP2100_M0,    -1,
  1385.     ADSP2100_I1,        ADSP2100_L1,    ADSP2100_M1,    -1,
  1386.     ADSP2100_I2,        ADSP2100_L2,    ADSP2100_M2,    -1,
  1387.     ADSP2100_I3,        ADSP2100_L3,    ADSP2100_M3,    -1,
  1388.     ADSP2100_I4,        ADSP2100_L4,    ADSP2100_M4,    -1,
  1389.     ADSP2100_I5,        ADSP2100_L5,    ADSP2100_M5,    -1,
  1390.     ADSP2100_I6,        ADSP2100_L6,    ADSP2100_M6,    -1,
  1391.     ADSP2100_I7,        ADSP2100_L7,    ADSP2100_M7,    0
  1392. };
  1393.  
  1394. static UINT8 adsp2100_win_layout[] = 
  1395. {
  1396.      0, 0,30,20,    /* register window (top rows) */
  1397.     31, 0,48,14,    /* disassembler window (left colums) */
  1398.      0,21,30, 1,    /* memory #1 window (right, upper middle) */
  1399.     31,15,48, 7,    /* memory #2 window (right, lower middle) */
  1400.      0,23,80, 1,    /* command line window (bottom rows) */
  1401. };
  1402.  
  1403.  
  1404. /*###################################################################################################
  1405. **    DEBUGGER STRINGS
  1406. **#################################################################################################*/
  1407.  
  1408. const char *adsp2100_info( void *context, int regnum )
  1409. {
  1410.     static char buffer[16][47+1];
  1411.     static int which = 0;
  1412.     adsp2100_Regs *r = context;
  1413.  
  1414.     which = ++which % 16;
  1415.     buffer[which][0] = '\0';
  1416.  
  1417.     if (!context)
  1418.         r = &adsp2100;
  1419.  
  1420.     switch( regnum )
  1421.     {
  1422.         case CPU_INFO_REG+ADSP2100_PC:      sprintf(buffer[which], "PC:  %04X", r->pc); break;
  1423.         
  1424.         case CPU_INFO_REG+ADSP2100_AX0:        sprintf(buffer[which], "AX0: %04X", core->ax0.u); break;
  1425.         case CPU_INFO_REG+ADSP2100_AX1:        sprintf(buffer[which], "AX1: %04X", core->ax1.u); break;
  1426.         case CPU_INFO_REG+ADSP2100_AY0:        sprintf(buffer[which], "AY0: %04X", core->ay0.u); break;
  1427.         case CPU_INFO_REG+ADSP2100_AY1:        sprintf(buffer[which], "AY1: %04X", core->ay1.u); break;
  1428.         case CPU_INFO_REG+ADSP2100_AR:        sprintf(buffer[which], "AR:  %04X", core->ar.u); break;
  1429.         case CPU_INFO_REG+ADSP2100_AF:        sprintf(buffer[which], "AF:  %04X", core->af.u); break;
  1430.  
  1431.         case CPU_INFO_REG+ADSP2100_MX0:     sprintf(buffer[which], "MX0: %04X", core->mx0.u); break;
  1432.         case CPU_INFO_REG+ADSP2100_MX1:     sprintf(buffer[which], "MX1: %04X", core->mx1.u); break;
  1433.         case CPU_INFO_REG+ADSP2100_MY0:     sprintf(buffer[which], "MY0: %04X", core->my0.u); break;
  1434.         case CPU_INFO_REG+ADSP2100_MY1:     sprintf(buffer[which], "MY1: %04X", core->my1.u); break;
  1435.         case CPU_INFO_REG+ADSP2100_MR0:     sprintf(buffer[which], "MR0: %04X", core->mr.mrx.mr0.u); break;
  1436.         case CPU_INFO_REG+ADSP2100_MR1:        sprintf(buffer[which], "MR1: %04X", core->mr.mrx.mr1.u); break;
  1437.         case CPU_INFO_REG+ADSP2100_MR2:     sprintf(buffer[which], "MR2: %02X", core->mr.mrx.mr2.u & 0x00ff); break;
  1438.         case CPU_INFO_REG+ADSP2100_MF:        sprintf(buffer[which], "MF:  %04X", core->mf.u); break;
  1439.  
  1440.         case CPU_INFO_REG+ADSP2100_SI:        sprintf(buffer[which], "SI:  %04X", core->si.u); break;
  1441.         case CPU_INFO_REG+ADSP2100_SE:        sprintf(buffer[which], "SE:  %02X  ", core->se.u & 0x00ff); break;
  1442.         case CPU_INFO_REG+ADSP2100_SB:        sprintf(buffer[which], "SB:  %02X  ", core->sb.u & 0x001f); break;
  1443.         case CPU_INFO_REG+ADSP2100_SR0:     sprintf(buffer[which], "SR0: %04X", core->sr.srx.sr0.u); break;
  1444.         case CPU_INFO_REG+ADSP2100_SR1:        sprintf(buffer[which], "SR1: %04X", core->sr.srx.sr1.u); break;
  1445.  
  1446.         case CPU_INFO_REG+ADSP2100_I0:        sprintf(buffer[which], "I0:  %04X", adsp2100.i[0]); break;
  1447.         case CPU_INFO_REG+ADSP2100_I1:        sprintf(buffer[which], "I1:  %04X", adsp2100.i[1]); break;
  1448.         case CPU_INFO_REG+ADSP2100_I2:        sprintf(buffer[which], "I2:  %04X", adsp2100.i[2]); break;
  1449.         case CPU_INFO_REG+ADSP2100_I3:        sprintf(buffer[which], "I3:  %04X", adsp2100.i[3]); break;
  1450.         case CPU_INFO_REG+ADSP2100_I4:        sprintf(buffer[which], "I4:  %04X", adsp2100.i[4]); break;
  1451.         case CPU_INFO_REG+ADSP2100_I5:        sprintf(buffer[which], "I5:  %04X", adsp2100.i[5]); break;
  1452.         case CPU_INFO_REG+ADSP2100_I6:        sprintf(buffer[which], "I6:  %04X", adsp2100.i[6]); break;
  1453.         case CPU_INFO_REG+ADSP2100_I7:        sprintf(buffer[which], "I7:  %04X", adsp2100.i[7]); break;
  1454.  
  1455.         case CPU_INFO_REG+ADSP2100_L0:        sprintf(buffer[which], "L0:  %04X", adsp2100.l[0]); break;
  1456.         case CPU_INFO_REG+ADSP2100_L1:        sprintf(buffer[which], "L1:  %04X", adsp2100.l[1]); break;
  1457.         case CPU_INFO_REG+ADSP2100_L2:        sprintf(buffer[which], "L2:  %04X", adsp2100.l[2]); break;
  1458.         case CPU_INFO_REG+ADSP2100_L3:        sprintf(buffer[which], "L3:  %04X", adsp2100.l[3]); break;
  1459.         case CPU_INFO_REG+ADSP2100_L4:        sprintf(buffer[which], "L4:  %04X", adsp2100.l[4]); break;
  1460.         case CPU_INFO_REG+ADSP2100_L5:        sprintf(buffer[which], "L5:  %04X", adsp2100.l[5]); break;
  1461.         case CPU_INFO_REG+ADSP2100_L6:        sprintf(buffer[which], "L6:  %04X", adsp2100.l[6]); break;
  1462.         case CPU_INFO_REG+ADSP2100_L7:        sprintf(buffer[which], "L7:  %04X", adsp2100.l[7]); break;
  1463.  
  1464.         case CPU_INFO_REG+ADSP2100_M0:        sprintf(buffer[which], "M0:  %04X", adsp2100.m[0]); break;
  1465.         case CPU_INFO_REG+ADSP2100_M1:        sprintf(buffer[which], "M1:  %04X", adsp2100.m[1]); break;
  1466.         case CPU_INFO_REG+ADSP2100_M2:        sprintf(buffer[which], "M2:  %04X", adsp2100.m[2]); break;
  1467.         case CPU_INFO_REG+ADSP2100_M3:        sprintf(buffer[which], "M3:  %04X", adsp2100.m[3]); break;
  1468.         case CPU_INFO_REG+ADSP2100_M4:        sprintf(buffer[which], "M4:  %04X", adsp2100.m[4]); break;
  1469.         case CPU_INFO_REG+ADSP2100_M5:        sprintf(buffer[which], "M5:  %04X", adsp2100.m[5]); break;
  1470.         case CPU_INFO_REG+ADSP2100_M6:        sprintf(buffer[which], "M6:  %04X", adsp2100.m[6]); break;
  1471.         case CPU_INFO_REG+ADSP2100_M7:        sprintf(buffer[which], "M7:  %04X", adsp2100.m[7]); break;
  1472.  
  1473.         case CPU_INFO_REG+ADSP2100_PX:        sprintf(buffer[which], "PX:  %02X  ", adsp2100.px); break;
  1474.         case CPU_INFO_REG+ADSP2100_CNTR:    sprintf(buffer[which], "CNTR:%04X", adsp2100.cntr); break;
  1475.         case CPU_INFO_REG+ADSP2100_ASTAT:     sprintf(buffer[which],"ASTA:%02X  ", adsp2100.astat); break;
  1476.         case CPU_INFO_REG+ADSP2100_SSTAT:     sprintf(buffer[which], "SSTA:%02X  ", adsp2100.sstat); break;
  1477.         case CPU_INFO_REG+ADSP2100_MSTAT:     sprintf(buffer[which], "MSTA:%02X  ", adsp2100.mstat); break;
  1478.         
  1479.         case CPU_INFO_REG+ADSP2100_PCSP:     sprintf(buffer[which], "PCSP:%02X  ", adsp2100.pc_sp); break;
  1480.         case CPU_INFO_REG+ADSP2100_CNTRSP:     sprintf(buffer[which], "CTSP:%01X   ", adsp2100.cntr_sp); break;
  1481.         case CPU_INFO_REG+ADSP2100_STATSP:     sprintf(buffer[which], "STSP:%01X   ", adsp2100.stat_sp); break;
  1482.         case CPU_INFO_REG+ADSP2100_LOOPSP:     sprintf(buffer[which], "LPSP:%01X   ", adsp2100.loop_sp); break;
  1483.         
  1484.         case CPU_INFO_REG+ADSP2100_IMASK:     sprintf(buffer[which], "IMSK:%02X  ", adsp2100.imask); break;
  1485.         case CPU_INFO_REG+ADSP2100_ICNTL:     sprintf(buffer[which], "ICTL:%02X  ", adsp2100.icntl); break;
  1486.         case CPU_INFO_REG+ADSP2100_IRQSTATE0:sprintf(buffer[which], "IRQ0:%X   ", adsp2100.irq_state[0]); break;
  1487.         case CPU_INFO_REG+ADSP2100_IRQSTATE1:sprintf(buffer[which], "IRQ1:%X   ", adsp2100.irq_state[1]); break;
  1488.         case CPU_INFO_REG+ADSP2100_IRQSTATE2:sprintf(buffer[which], "IRQ2:%X   ", adsp2100.irq_state[2]); break;
  1489.         case CPU_INFO_REG+ADSP2100_IRQSTATE3:sprintf(buffer[which], "IRQ3:%X   ", adsp2100.irq_state[3]); break;
  1490.         
  1491.         case CPU_INFO_REG+ADSP2100_FLAGIN:     sprintf(buffer[which], "FI:  %X   ", adsp2100.flagin); break;
  1492.         case CPU_INFO_REG+ADSP2100_FLAGOUT: sprintf(buffer[which], "FO:  %X   ", adsp2100.flagout); break;
  1493. #if SUPPORT_2101_EXTENSIONS
  1494.         case CPU_INFO_REG+ADSP2100_FL0:     sprintf(buffer[which], "FL0: %X   ", adsp2100.fl0); break;
  1495.         case CPU_INFO_REG+ADSP2100_FL1:     sprintf(buffer[which], "FL1: %X   ", adsp2100.fl1); break;
  1496.         case CPU_INFO_REG+ADSP2100_FL2:     sprintf(buffer[which], "FL2: %X   ", adsp2100.fl2); break;
  1497. #endif
  1498.  
  1499.         case CPU_INFO_FLAGS:
  1500.             sprintf(buffer[which], "%c%c%c%c%c%c%c%c",
  1501.                 r->astat & 0x80 ? 'X':'.',
  1502.                 r->astat & 0x40 ? 'M':'.',
  1503.                 r->astat & 0x20 ? 'Q':'.',
  1504.                 r->astat & 0x10 ? 'S':'.',
  1505.                 r->astat & 0x08 ? 'C':'.',
  1506.                 r->astat & 0x04 ? 'V':'.',
  1507.                 r->astat & 0x02 ? 'N':'.',
  1508.                 r->astat & 0x01 ? 'Z':'.');
  1509.             break;
  1510.         case CPU_INFO_NAME: return "ADSP2100";
  1511.         case CPU_INFO_FAMILY: return "ADSP2100";
  1512.         case CPU_INFO_VERSION: return "1.0";
  1513.         case CPU_INFO_FILE: return __FILE__;
  1514.         case CPU_INFO_CREDITS: return "Copyright (C) Aaron Giles 1999";
  1515.         case CPU_INFO_REG_LAYOUT: return (const char*)adsp2100_reg_layout;
  1516.         case CPU_INFO_WIN_LAYOUT: return (const char*)adsp2100_win_layout;
  1517.         case CPU_INFO_REG+10000: return "         ";
  1518.     }
  1519.     return buffer[which];
  1520. }
  1521.  
  1522. unsigned adsp2100_dasm(char *buffer, unsigned pc)
  1523. {
  1524. #ifdef MAME_DEBUG
  1525.     extern unsigned dasm2100(char *, unsigned);
  1526.     return dasm2100(buffer, pc);
  1527. #else
  1528.     sprintf(buffer, "$%06X", RWORD_PGM(pc));
  1529.     return 1;
  1530. #endif
  1531. }
  1532.  
  1533.